	  iDIOT Compiler v1.67/1.78 (Man. Rev #Lkffs)
		(c)2018 Naspite Labs


**note, the PARSER component has its own seperate manual**
** active PARSER by typing PARSER at the LINE # prompt  **


MANUAL CONTENTS
==========================================
1.	What Is iDIOT Compiler
2.	What iDIOT Compiler Is NOT
3.	Examples Of How iDIOT Is Faster
4.	SETUP
5.	COMMANDS IMPLIMENTED
6.	VARIABLES VRS #NUMBERS
7.	HOW LET WORKS (AKA THE MATH)
8.	FOR NEXT LOOPS... (caution here!)
9.  	ASM - MANUAL ASSEMBLY ENTRY
10.	LINE NUMBER INFO
11.	COMPILE A PROGRAM
12.	POTENTIAL PITFALLS
13.	*A GAME EXAMPLE
14.     ARCHIVER FEATURE
15.	PARSER MODE SNIPPET
16.	*FURTHER UPGRADES AND FUTURE FEATURES


1.  What Is iDIOT Compiler
==========================================

Idiot Compiler is attempt at creating a way of assemblizing Applesoft Basic code in
an super easy way that keeps the output code as light and uncombersome as possible.  
This project has taken a vastly different approach to creating files in comparison
to the mainstream compilers TASC, BEAGLE, Hayden and Einstein in several key ways.

We have reduced and pretty much eliminated all RUNTIME code.  This not only makes the
compiled program one block of memory encorporating all the code, variables and subroutines,
it also allows much faster execution as the old RUNTIME standard bloat file sizes and
eliminates the swiss army knife weight of routines that are never needed or called upon.

In every decision of code output, we have choosen the fastest option, even if it lowers
native Applesoft compatibility just a tad.  By doing away with Applesoft-type housekeeping
things, we can blaze past and out-perform previous compilers by a large margin!  The last
great thing about iDIOT Compiler, is the output code can easily be read by an assembly
programmer... something that none of the others can claim!



2.  What iDIOT Compiler Is NOT
==========================================

As this is a "Home-Brew" compiler, it is very simple.  There are many things it currently
cannot do and will never do.  If you want an ALL-IN-ONE solution, the commerical compilers
are a better overall package and much less hassle free.

Consider this COMPILER to be an Applesoft Assembler.  The output code is/can be multiple
times faster than its nearest competetor on the things that it does do, so examine your
Applesoft program and see if its out of the scope of this compiler before attemting to
assemblize it.

	It does not do	COMPLEX MATH
			NEGATIVE NUMBERS
			STRING VARIABLES
			#'s ABOVE 24 BIT (*16,777,216)

The inputs are very similar to Applesoft like statements, but do not confuse that with total
compatibility. There are many decisions taken to make the output code INCREDIBLY FAST, but
do be advised functionality is limited!



3.  Examples Of How iDIOT Is Faster
==========================================

Example 1... FOR/NEXT LOOPS
	For next loops are rather complex.  In standard Applesoft and in most subsequent
	compilers, it requires 16 bytes of STACK for it to exist.  What iDIOT champions
	is eliminating the STEP and COMPARES out of the equation, bringing it down to
	a mere 2-BYTES that brings the counter from the starting point to ZERO.  If
	the FOR/NEXT starts at a number larger than 1, it merely subtracts the START
	and END numbers resulting in that many number of loops.  The Step capability
	and variableness is missing but if required can be additionally programmed in
	and was removed because not every sistuation requires these abilities.

Example 2... 16BIT MATH vrs FLOATING POINT, OR EVEN HIGH LEVEL INTEGER
	Applesoft is notoriously slow, and this is because almost every MATH operation
	is done twice, once in floating point numbers and integer. Converting between
	the two systems does allow for a wide range of numbers, but these routines
	are incredibly bloaty and have slow execution speeds.  Compilers help a lot, and
	most champion INTERGER capability in some circumstances.  However, for most
	sistuation they still are using math well out fo the scope of the numbers being
	used... 32 bit Integer equations compared to 16bit are *8 times slower at best.

	IDIOT Compiler uses switchable 8bit, 16 bit and 24 bit numbers in all operations and F
	and even in IF comparison statements... and even faster 8BIT Math in things like 
	poking numbers,	LORES Graphics and other relevant sistutions.  The most recent updates
	further	incrase speedups for 8BIT MATH statements and 8BIT Compares. 

	Also employed is the LET-QUICKIES MATH,  that do simple things like increase a 
	variable number +1 or multiply times x2... these can potentially speedup your
	output program 10x over other compilers without batting an eyelash.



4.  SETUP
==========================================

Upon booting iDIOT Compiler, you will be greeted with a simple prompt.
	such as-------------->>	   [LINE #: ]

		Here if you are continuing an old project, you can type 
		in the # or name of the line you wish to work on!

If you wish to RESET the compiler and start a new project, 
		type--------->>  RESET

		This will clear a host of things like:
			VARIABLES
			LINE NUMBERS
			FOR NEXT LOOP COUNTERS
			FINISHED LINES ON DISK

The only prompt you will be given is:
		[  FOR/NEXT LOOP DEPTH #: ]

			Here you must give it a number of how deep your
		FOR NEXT LOOPS can go.  This is because IDIOT COMPILER
		preallocates variable space before you type in your
		first line of code.  This can be a number between 0 and
		however many you want.  Remember, each FOR/NEXT loop
		uses only 2 BYTES of space per LOOP, but it is not
		limited by the traidional stack as its memory is in
		the variable table and does not use APPLE II Stack Space.

	Your compiler is now RESET.   Once you do a RESET, the old program/source 
	that you were previously working on is no longer resident on the disk and 
	will be lost... (Source only... COMPILED PROGRAMS will not be erased).


5.  COMMANDS IMPLIMENTED
==========================================

	-------INTERNAL COMMANDS-----------------
	
	COMPILE-	COMPILES YOUR PROGRAM WITH CURRENT FILES/DATASETS
	QUIT-		EXITS COMPILER PROGRAM
	RESET-		RESETS ALL PROGRAM FILES, LINE NUMBERS AND VARIABLES
	END-		IF INSIDE A LINE IT ENDS LINE, SAVES DATA TO FILE.
	LIST-		LISTS ALL FILES IN YOUR CURRENT PROGRAM (MAY NOT BE IN ORDER)
	DELETE-		DOES THE LINES COMMAND AND ALLOWS YOU TO DELETE AN (ACTIVE LINE)
	COMMANDS-	SHOWS LIST OF VALID COMMANDS
	HELP-		SHOWS A SIMPLE HELP SCREEN FOR QUICK REFERENCE
	CANCEL-		CANCELS YOUR CURRENT LINE WITHOUT SAVING
	VAR-		TELLS LOCATION IN MEMORY OF VARIABLES
	PARSER-		TURNS ON PARSER (or) READS/INPUTS AN ALREADY CREATED APPLESOFT PROGRAM
	("JUST"-ENTER)	MOST CASES WILL DROP YOU OUT OF CURRENT INSTRUCTION WITHOUT CODING IT...
	

	-------COMPILER COMMANDS-----------------

	ASM		MANUAL ASSEMBLY MODE ENTRY
	CALL-		CALLS SUBROUTINE	--(VAR OR #XX)--
	CANCEL-		REJECTS CURRENT LINE WORKING ON
	COLOR-		LORES COLOR		--(VAR OR #XX)--
	DEC-		16BIT DEINCREMENT	--(VAR       )--
	DEC8-		8BIT DEINCREMENT	--(VAR       )--
	DEC24-		24BIT DEINCREMENT	--(VAR       )--
	DOS-		BLOAD/BRUN ARGUMENT- NO PRINT CHR$(4) OR " " MARKS NEEDED
	END-		ENDS CURRENT LINE (NOT LIKE APPLESOFT END)
	FLASH-		CHANGES TO 'FLASH' TEXT
	FOR-		FOR/NEXT LOOP SETUP
	GR-		TURNS ON LORES SCREEN/CLEARS
	GOSUB-		GOSUB TO LINE NUMBER *(CAN EVEN BE A NAME)
	GOTO-		GOTO LINE NUMBER *(CAN EVEN BE A NAME)
	HLIN-		LORES HORIZONTAL LINE 	--(VAR OR #XX)--
	HTAB-		PLACES CURSER AT HORIZONTAL TEXT LOCATION --(VAR OR #XX)--
	IF-		IF SUBSTRUCTURE (COMPARES NUMBERS = OR < OR >)
	IF8-		IF8 SUBSTRUCTURE (COMPARES 8BIT NUMBERS = OR < OR >)
	IF24-		IF24 SUBSTRUCTURE (COMPARES 24BIT NUMBERS = OR < OR >)
	INC-		16BIT INCREMENT 	--(VAR       )--
	INC8-		8BIT INCREMENT		--(VAR	     )--
	INC24-		24BIT INCREMENT		--(VAR       )--
	INVERSE-	INVERSES TEXT
	LET-		LET #= SUBSTRUCTURE FOR 16-BIT MATHS  *(NORMAL DEFAULT)*
	LET8-		LET #= SUBSTRUCTURE FOR  8-BIT MATHS
	LET24-		LET #= SUBSTRUCTURE FOR 24-BIT MATHS
	NO RETURN-	ENDS LINE, FOR LINES ABOVE *999, IT CANCELS AUTOMATIC (RTS)
	NORMAL-		RETURNS TEXT BACK TO NORMAL
	PARSER-		SWITCHES TO (PARSER CODE ENTRY MODE)... *SEE SEPERATE MANUAL
	PDL-		PADDLE (#0 = LEFT-RIGHT or #1 = TOP-BOTTOM)    --(VAR 	   )--
	PEEK-		MAKES VARIABLE EQUAL MEMORY BYTES	--(VAR 	   )--
			*also---  Double Peek Two Memory bytes  A=Peek(b)+Peek(c)*256
	PLOT-		PLOTS CURRENT COLOR ON LORES SCREEN	--(VAR OR #XX)--
	PRINT-		PRINTS "STRING" OR VARIABLE
	PR#0-		TURNS ON 40 COL MODE (DOES NOT CLEAR SCREEN)
	PR#3-		TURNS ON 80 COL MODE (DOES CLEAR SCREEN)
	RETURN-		PUTS (RTS) IN SUBROUTINE OR WORKS AS *END INSIDE NORMAL LINES
	RND-		SIMPLE 8BIT RANDOM NUMBER GENRATOR, PLACES RND(MAX # INTO VARIABLE)
	RUN-		RESTARTS PROGRAM... ALSO CLEARS VARIABLES... (*do not use GOTO 0)
	SCRN-		GETS LORES COLOR AT PLOT X,Y INTO VARIABLE  --(VAR OR #XX)--
	SQR-		SQUARE ROOT (16BIT)
	STEP-		STEPS a FOR/NEXT LOOP (Location is different, see  FOR/NEXT LOOP INFO file
	TEXT-		TURNS ON TEXT MODE
	VLIN-		LORES VERTICAL LINE	--(VAR OR #XX)--
	VTAB-		PLACES CURSER AT VERTICAL TEXT LOCATION --(VAR OR #XX)--
	WAIT-		WAITS IN 1/10 SECOND INCREMENTS (MAX 255 = 25.5 SECONDS)


6.  VARIABLES VRS #NUMBERS
==========================================

	Whenever you see a prompt, such as  (VAR OR #XX), this is where you can enter
	data pertaning to the BASIC Statement you are trying at assemblize.
	The prompt may change, allowing only a variable or a number entry. 
	 (VAR OR #XX) ... (VAR     ) ....(      #XX)... or (ADR       )

	To enter a number... just enter the number.  If you enter any weird charrecters other
	than numbers, it will automatically assume its a variable.. even if it has $ or # in 
	the 'string'.

	** Be cautious of limitation values in the data you are entering... for example, if
	entering an 8 bit number... if your typed value is larger than 255... you may loose
	or have incorrect data.

	To enter a variable... type the variable name. It can be named any length of normal charrecters,
	so pretty much anything you want to call it... even strings including numbers are acceptable!!!

	If a variable is not in the data table... aka never been used before, it will automatically 
	create a new 24bit 3byte variable...

	There is very little error checking while this is happening, so please be cautious!  If you
	indeed find out you trying to do one thing, and the computer another, make the input BLANK
	and it will return you back before you started the command.  It may take several blank inputs.



7.  HOW LET WORKS (AKA THE MATH)
==========================================

	The LET command allows variables to be equal to something, like INTEGER BASIC.
	In IDIOT COMPILER... LET allows variables to equal numbers, or simple equations.
		For Instance...  
			LET  A = B 
				A can equal B (or any other variable)... or A = #number

			LET A=B+C is simple addition.. you dont have to use different variables
				If the desired effect is...   (A = B + C) OR (A = B + #5) OR (A = A + B)

			LET A=B-C is same as addition.. HOWEVER the only limitation is you can not
				have the result be a negative number... 
			
			LET A=B*C is same as above... only with multiplication.

			LET A=B/C is same as above... only with division. **[Result is Integer Only]

			*** You can use the same agrument twice if desired...
				LET A=A+B is a perfectly legal math statement.

		SWITCHING LET MODES
			There are THREE (3) LET modes in Idiot Compiler.  They allow you to do math in
			8 bit, 16 bit and 24 bit.  The various modes have slightly different function
			sets, so you should be aware of the limitations.  By default the compiler is
			switched into LET16 mode, which is 16bit math.  16bit math is the most useful
			as it has the most features available, although you can switch to 8bit math for
			certain functions to gain an even faster speedboost.  There is also a 24bit mode
			to allow for larger numbers.  

			To switch modes, type  LET8 / LET16 or LET24.  Changing the (LET) functions also
			swap in the IF compare statements for that particular bitset.

		SPECIAL 16BIT QUICKIES   (Also available in 8bit and 24bit number mode / functions vary)
			YOU MAY find an OPTION called 16BIT QUICKES.... this gives you the option to do a 
			small subset of features in far less code and faster speeds than regular generic
			routines... such as INC or DEC a variable by 1, or to DIVIDE a variable by 2.
			These functions speed up your program to BEST HAND-WRITTEN ASSEMBLY SPEED, and
			is encouraged to be used to give the APPLESOFT programmer huge advantages over
			other compilers!  (*more functions to be added in subsequent versions!)

		LET8
			LET8 instruction does the exact same thing as the LET command above EXCEPT
			it will employ 8bit math and values only.  It can allow for even FASTER code
			but be extremly cautious not to make the values exceed 255 or max 8bit values.

			LET8 also allows SPECIAL 8BIT QUICKIES and also has an associated IF8 command.


		LET24
			LET24 is the same as above, only allows for 24bit numbers with maximum values
			upto 16,777,216!  Limited functions only to ADD/SUB/INC/DEC.
		
			LET24 also allows SPECIAL 8BIT QUICKIES and also has an associated IF24 command.


8.	FOR NEXT LOOPS... (caution here!)
==========================================

**	*FOR STEP CAPABLE LOOPS, see FOR NEXT LOOP HOW-TO textfile


To create a FOR-NEXT LOOP, use the following code.

( FOR X=1 to 10: CODE LOOP TO EXECUTE: NEXT X)

Add program lines to your original APPLESOFT code like the example.

10 X=1
20 CODE LOOP TO EXECUTE
30 IF X<10 THEN X=X+1:GOTO 20

Doing something similar to the above will keep your ASM basic translation
identical to the APPLESOFT original in function, and also allow usage
of the FOR-NEXT-LOOP as a variable.

CAUTION....
===================================================================
NOTE 1... see line 10.. the variable IS your FOR starting number

NOTE 2 ... see line 30.. the INCREMENET such as X=X+1 is the STEP. 
**If you have a step greater than 1, look at the FOR NEXT LOOP HOW-TO textfile.

NOTE 3... see line 30.. the X<10 must contain a number equal to the
max value of FOR.  The X in line30 is 10 as per the original Applesoft.




9.  ASM - MANUAL ASSEMBLY ENTRY
==========================================

	New in version 1.28 of Idiot Compiler, you can now enter 'basic' assembly instructions. By doing
	this advanced entry mode, you can customize small parts of the compiled code to even be more
	streamline than even the best compiled code... turning, churning and tuning your code to be just
	as if you programmed it in pure assembly.  The major caution to this is its direct access to code,
	so the Compiler will not be able to do any error checking to ensure its legal syntax or even valid
	executable code.  This is primarily for the advanced user who already knows Assembly programming.

	A simple example of how it could be used.  (REMEMBER, ONLY DECIAML ENTRY IS ALLOWABLE)

		Say you have the basic commands:  ( POKE 35000,0:POKE 35001,0:POKE 35002,0)
		By using the compiler with the poke command, you code will look like this.
			POKE	LDA #0
				STA 35000
			POKE	LDA #0
				STA 35001
			POKE	LDA #0
				STA 35002
		In the overall skeme of things, its not bad for a compiler... 
		but in DIRECT ASM MODE, you could type in this...
			ASM	ASM: LDA #0
				ASM: STA 35000
				ASM: STA 35001
				ASM: STA 35002
				ASM: END

	To CANCEL input, say a typo error, type CANCEL as a command, and nothing will be remembered,
	bringing you back to your previous BASIC LINE NUMBER.

	To FINISH your assembly input, simply type END, and it will added to the CURRENT LINE NUMBER

	*** Only use decimal inputs, do not attempt to use variables the compiler has setup internally.***


10.  LINE NUMBER INFO
==========================================
			
	This compiler can only work with LINES 1 thru 998.  Do not create line numbers above 998
	(1000, 1010, 20500 ect...)... for normal execution workflow.

	That being said... there is a caviot to this.  A line number has the potential to be larger than 999
	in special circumstances... those mainly in GOTO , GOSUB inside FOR/NEXT Loops.  These line numbers
	"names" can be just about ANY Length in size (over 4 charrecters).. can be numbers or a word... 
	but they must be longer than 3 charrecters... like   GOSUB10 or FRUITIE are accepable names.  
	These can ONLY be accessed by the GOTO, GOSUB and FOR NEXT LOOP commands, they will not execute on
	their own in the course of a normal program.


11.  COMPILE A PROGRAM
==========================================

	Once a program and all of its lines are entered, type COMPILE to have it compiled.  This is a very
	slow process due to everything is writen to and processed as text files. 

	Remember, if there are any logic errors in your program, they will not show up until you attempt
	to run the new program.  However, if there are line errors, say a missing line number once referenced
	to among the other code, the compiler will halt midway thru stating that a particular argument is not
	found.  This could be do to oversight by not typing in the line, or if durring editing it may have
	been accidently deleted.  Also, a problem with a missing GOSUB/GOTO could result if you do not fully
	understand how the FOR/NEXT loop is processed in IDIOT COMPILER.

	Idiot Compiler has been written to retain all of the essential compile code, so if changes need to be
	made after you compiled a program, you can potentially change one or several lines without effecting
	the rest of the program.  You can change the lines you think are needed, or add a few more, then
	recompile!

	ONCE A PROGRAM IS COMPILED SUCCESSFULLY... you can find out more information about the program in several
	ways.  Before resetting the compiler disk for the next project, several files about your new program
	is saved onto the disk.

	**VARIABLES tells you the memory location of all variables inside the program.  If you see a NAME and then 
	a number after it, this is the lowest position of memory for it.  Every variable takes 3 locations, so a 
	variable names AA and is located at 30010 means that its actually in 30010, 30011 and 30012, lowest value
	to highest (24bit numbers).

	**PROGRAM.LISTING is a table of translated basic where each PROGRAM LINE exists in memory.  This is here
	to keep the compiler straight while its doing its 3 step translation process... but an assembly
	programmer can take advantage of this information by manipulating variables and calling parts of a 
	compiled program.  Idiot Compiler champions itself as it creates the most understandable code of any
	Applesoft Compiler, so you can chase and follow its easy to understand structure.  You may be able
	to take advantage of this information is unique ways, but it usually isnt nessasary for the average
	Applesoft programmer.

	





12.  POTENTIAL PITFALLS...
==========================================

	YOU MUST DO "RESET" EVERYTIME YOU START A NEW PROJECT... TO CLEAR THE LINES LIST, VARIABLES ECT...
	
	IF YOU ENTER IN INCORRECT COMMANDS, THERE IS NO BACK-FEATURE... so be extremely careful entering data.
	Remember... this is a compiler... not a commandline interpeter or applesoft editor... it is highly
	recommended you make sure your program is finished and bug tested before compiling... also advice for
	any commerical compiler.   *(You can always type CANCEL to cancel a bad line, then restart fresh).
	*(You can also DEL) a line number to erase it... or you can restart the line number over.

	LINENUMBERS can be ODD... see #9....

	FOR NEXT Loops are a little different than Applesoft... but you stil can do them!  * (See Section 8)*

	*** ENTERING CODE... BE CAUTIOUS OF ENTERING NUMBERS....  Numbers must be fully numeric.  It calculates
	the value of the argument, so if it contains ANY STRING content, it will fail the numeric test and
	automatically call your input a VARIABLE.  If the variable does not exist yet, it will automatically
	create a brand new one for use and add it to the VARIABLE TABLE.  Each VARIABLE takes up 3 bytes of
	memory in your code, so try not to make a whole bunch of unneeded variables.   Variables are dynamicaly
	created and even if you cancel a code line, those variables will still remain in the table.
	   ***  If you do spot an error in the code, type CANCEL... and try typing the line over. **

	ADVANCED PROGRAMMER ONLY:    IF8 and LET8 commands allow for extremely fast code processing and math 
	equations.  Use these instructions with caution and care.  They adhere to all the standard 16BIT LET 
	and IF operations but if you exceed the maximum 8bit value of 255 it could give false or incorrect
	results later on in your program.  If you are unsure about a variables value it is recommended to 
	use the regular LET and IF commands.

	***ASM - MANUAL ASSEMBLY MODE...  WITH VERSIONS 1.28 AND ABOVE, YOU CAN NOW ENTER MANUAL ASSMEBLY CODE!
	THE CODE MUST BE IN FULL DECIMAL NUMBERS, SIMILAR TO WHAT THE CODE WOULD BE LIKE IN BASIC.  THERE IS NO
	SUPPORT FOR VARIABLES ACCESS... THERE IS NO ERROR CHECKING OF ANY KIND ON THE ENTRY.

	***Be careful of the LET mode you are in.  If you are attempting to do 24bit larger number math and or
	comparisons but another mode is swapped in, it is quite easy to overlook that fact and the results
	of your code could create unintended side effects.  The Compiler automatically by default is swapped
	into 16BIT mode, but can be changed by typing LET8/LET16/LET24.  Also, be aware that the different
	modes may have a different set of predefined options and can vary from one mode to another.
		



13.  *A GAME EXAMPLE
==========================================

	Provided with Idiot Compiler 1.15 is a 48kb mini game that has been compiled with IDIOT COMPILER to
	prove it has practical applications and not just an exercise/proof of concept.  The original APPLESOFT
	is also included for your examination, along with line numbers it matches upto in assembly code.
	If you desire to try the game in pure applesoft, remove all refrences to CALL 36100 as its linked to
	a cool exernal SFX Multi-tasking Audio engine. 
		 Keys are as on screen... the game was compiled using 16bit math.


14.  ARCHIVER FEATURE
==========================================
	The programs ARCHIVE and RESTORE allow a person to save the source code file of a compiled program,
	allowing all the major components to be saved as one archive file and to be uncompacted at a future
	date to continue working on a project.  The program must have been recently compiled durring your
	work session in order for this to work.  HOWEVER, you can leave a project open even if you shut off
	your computer and continue at a later date, as long as you havent RESET the compiler.
	***   It is recommended to REBOOT the disk when starting work on a NEW PROJECT.  ***

	To ARCHIVE...  COMPILE your program that is resident on the disk.  Then run the ARCHIVE program.

	To RESTORE...  Make sure to RESET the compiler before restoring a project.  The RESTORE program
			will automatically warn you if a project is currently open, and will not allow
			you to RESTORE an archived program.

			**The things it will restore to your disk...    LINE NUMBER FILES
								 	COMPILED LINE NUMBER LIST
			                                         	VARIABLE FILE LIST


15.  PARSER MODE SNIPPET
==========================================
	The PARSER is a new upgrade to IDIOT COMPILER to allow faster code entry and more code similtude
	to what you would find in APPLESOFT insted of the SINGLE COMMAND STRUCTURE of REGULAR MODE.

	The overview to PARSER mode is in a seperate file called TUTORIAL PARSER ENTRY MODE.
	Please read that to better understand the quirks and how to enter your basic programs.
	

16.  *FURTHER UPGRADES AND FUTURE FEATURES
==========================================
	
	If you need help with IDIOT compiler, contact me at   ( TREEHOUSE2000US (AT) YAHOO.COM )
	and i'll write you back, or get ahold of me on facebook PM.  I'll do the best I can to help 
	you out.. a few more functions are planned in the future that will make it far more useful... 

	There are a few older demonstration videos on the LASERACTIVEGUY youtube channel in the APPLE II 
	section that will help you understand how instructions are entered and workflow.  Yes, the 
	compiler is much more slower and complicated then other compilers... but will generate code that
	is very lighting fast in comparison.  

	Consider the Idiot Compiler a sort of Applesoft-Assembler than a compiler...
								- Tom at Naspite
	

